Games of Daze

home *** CD-ROM | disk | FTP | other *** search

/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / libs / 3dvect39 / gus.asm < prev next >

Wrap

Assembly Source File | 1994-10-30 | 46.7 KB | 1,614 lines

;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; ; Sound support - GUS & SB ; ; Labels begining with: ; _sfx - generic sound commands, both cards ; _gs - GUS labels ; _sb - Sound Blaster labels ; ; Notes and Examples: ; ; call _sfx_find ; for both soundcards ; jc no sound card installed ; ; mov edx,_lomembase ; DMA buffer * ALL this data is ignored * ; mov ebx, 1024 ; DMA buffer size * if the user has a GUS * ; mov ecx, 22000 ; sample rate ; mov eax,_lomembase ; add eax, ebx ; samples are right after DMA buffer ; call _sfx_init ; call this for both soundcards (SB and GUS) ; mul ebx,200000 ; 200000 bytes of sample memory required (0 if GUS) ; add _lomembase,eax ; bump up low memory because of DMA (0 if GUS) ; add _lomembase,ebx ; bump up low memory because of samples required (0 if GUS) ; ; call _sfx_uninit ; done, clear soundcard ; ; Notes: Original GUS code (now modified) from GS.ASM by Thomas Pytel, aka TRAN ; Sound Blaster code (Gravis Emulation) by John McCarthy, aka FLYNN. ; ; Send me a postcard! ; ; John McCarthy ; 1316 Redwood Lane ; Pickering, Ontario. ; Canada, Earth, Milky Way (for those out-of-towners) ; L1X 1C5 ; ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ .386p code32 segment para public use32 assume cs:code32, ds:code32 include pmode.ext include irq.ext include file.ext public _sfx_find ; find if sound device available public _sfx_init ; intialize sound device public _sfx_uninit ; unintialize sound device public _sfx_putram ; put to ram public _sfx_getram ; get from ram public _sfx_shutup ; turn single voice off public _sfx_relvolume ; relative volume control public _sfx_setvolume ; set volume of channel public _sfx_getfreq public _freqtbl ; precalculated frequencies for c0 to b4 public _sfxnumvoices ; number of voices to mix public _sfxmem ; next available location in sample memory public _sfxram ; amount of RAM on card public _sfxsign ; sign for XOR'ing of samples (only during ; initial transfer to card) public _sfxtype ; card installed, 0 = none, 1 = GUS, 2 = SB public _vccmnd, _vccntrl, _vcsbeg, _vclbeg, _vclend, _vcfreq, _vcpan, _vcvol public _mix_volume align 4 ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Generic voice handling stuff ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _sfx_init dd offset _return_null ; jump vectors to appropriate code _sfx_uninit dd offset _return_null _sfx_putram dd offset _return_null _sfx_getram dd offset _return_null _sfx_shutup dd offset _return_null _sfx_getfreq dd offset _return_null _sfxsign db 0 ; signed data not, 0 = SB, 80h = GUS _sfxmem dd 0 ; next free location in GUS or SB virtual memory _sfxram dd 0 ; amount of available GUS or SB virtual memory _sfxnumvoices db 16 ; number of voices (up to 32) _sfxmiddlec dw 8664 ; Hz assigned to middle C _sfxtype db 0 ; card installed, 0 = none, 1 = GUS, 2 = SB ; bit 1, 1 = virtual ram or 0 = GUS ram/no ram _vccmnd db 32 dup(?) ; virtual channel command bits ; bit 0: volume change ; bit 1: balance change ; bit 2: frequency change ; bit 3: sample note-on ; bit 4: sample continues into next chunk (SB only) _vccntrl db 32 dup(?) ; virtual channel voice control ; bit 3: enable loop ; bit 4: bi-directional loop ; bit 6: 0=forward, 1=reverse _vcsbeg dd 32 dup(?) ; virtual channel sample begin _vclbeg dd 32 dup(?) ; virtual channel loop begin _vclend dd 32 dup(?) ; virtual channel loop end _vcfreq dw 32 dup(?) ; virtual channel frequency value _vcpan db 32 dup(?) ; virtual channel pan position _vcvol db 32 dup(?) ; virtual channel volume (high byte) _mix_volume db 32 dup(15) ; mixing volume (each channel) aclbeg dd 32 dup(?) ; actual channel loop begin aclend dd 32 dup(?) ; actual channel loop end acfreq dw 32 dup(?) ; actual channel frequency value acpan db 32 dup(?) ; actual channel pan position acvol db 32 dup(?) ; actual channel volume (high byte) acpos dd 32 dup(?) ; actual channel position (SB only) acstep db 32 dup(?) ; actual channel last step position (SB only) accntrl db 32 dup(?) ; actual channel voice control (SB only) accmnd db 32 dup(?) ; actual channel command (SB only) _freqtbl dw 60 dup (0) rawfreq dw 2166,2294,2431,2573,2728,2891,3063,3245,3438,3642,3859,4088 dw 4332,4589,4862,5147,5457,5782,6126,6490,6876,7285,7718,8177 dw 8664,9179,9725,10294,10915,11565,12252,12981,13752,14571,15437,16355 dw 17328,18358,19450,20589,21831,23130,24505,25962,27505,29142,30874,32710 dw 34656,36716,38900,41179,43663,46260,49011,51925,55010,58284,61749,65421 ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Null soundcard (default) ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _return_null: xor eax,eax xor ebx,ebx xor ecx,ecx xor edx,edx xor esi,esi xor edi,edi xor ebp,ebp ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Macros ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ vol = 1 ; alter volume pan = 2 ; alter pan position freq = 4 ; alter frequency play = 8 ; start/re-start sample cont = 16 ; continue with SB sample (for next chunk, SB only) shutup = 32 ; turn channel completly off loop_on = 8 ; looping enable loop_bi = 16 ; bi-directional loop loop_rev = 64 ; loop direction, 1 = backwards gusoutb macro index,value mov al,&index out dx,al add dl,2 mov al,&value out dx,al sub dl,2 endm gusoutw macro index,value mov al,&index out dx,al inc edx mov ax,&value out dx,ax dec edx endm gusinb macro reg,index mov al,&index out dx,al add dl,2 in al,dx sub dl,2 ifnb <reg> mov reg,al endif endm gusinw macro reg,index mov al,&index out dx,al inc edx in ax,dx dec edx ifnb <reg> mov reg,ax endif endm sbout macro data local wait wait: in al,dx or al,al js wait mov al,data out dx,al endm ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Perform Initial test for card: Set jump vectors for card found ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _sfx_find: mov _sfxtype,0 call _gus_find jc fd_looksb mov _sfx_init ,offset _gus_init mov _sfx_uninit,offset _gus_uninit mov _sfx_putram,offset _gus_putram mov _sfx_getram,offset _gus_getram mov _sfx_shutup,offset _gus_shutup mov _sfx_getfreq,offset _gus_getfreq mov _sfxtype,1 mov _sfxsign,0 ret fd_looksb: call _sb_find jc _ret mov _sfx_init ,offset _sb_init mov _sfx_uninit,offset _sb_uninit mov _sfx_putram,offset _sb_putram mov _sfx_getram,offset _sb_getram mov _sfx_shutup,offset _sb_shutup mov _sfx_getfreq,offset _sb_getfreq mov _sfxtype,2 mov _sfxsign,0 ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Set mixing volume of channel EBX ; In: ; EBX - voice channel # ; AL - volume level ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _sfx_setvolume: cmp al,0 jge sv_1 mov al,0 sv_1: cmp al,15 jle sv_2 mov al,15 sv_2: mov _mix_volume[ebx],al or _vccmnd[ebx],vol ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Change volume of channels (relative) ; In: ; BL - channel to start at ; CL - channel to end at ; DL - 1 = inc, -1 = dec ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _sfx_relvolume: sub cl,bl inc cl movzx ebx,bl movzx ecx,cl av_1: mov al,_mix_volume[ebx] add al,dl call _sfx_setvolume inc ebx loop av_1 ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; GUS lowlevel interface. Part II - modified from TRAN's original gs.asm ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ public _gus_handler public _gus_shutup public _gus_init public _gus_uninit public _gus_putram public _gus_getram public _gus_find public _gus_getfreq public _gusport public _gusirq ormgusirqvect dd ? ; old real mode GF1 IRQ vector rmgusirqbuf db 21 dup(?) ; buffer for rm GF1 IRQ callback code gusport102 dw ? ; GUS port + 102h gusport103 dw ? ; GUS port + 103h gusport104 dw ? ; GUS port + 104h gusport107 dw ? ; GUS port + 107h _gusport dw 220h _gusirq db 11 whichguscontrol dd -1 ; irq timing control number port103val db 43h ; value to set on exit from IRQ irqm0tbl dw 0c089h,0a0e6h gusirqvaltbl db 0,0,41h,43h,0,42h,0,44h,0,0,0,45h,46h,0,0,47h voltbl db 004h,0a0h,0b0h,0c0h,0c8h,0d0h,0d8h,0e0h db 0e4h,0e8h,0ech,0f0h,0f2h,0f4h,0f6h,0f8h ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Gus IRQ - useless, never called ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ gus_irq: push eax mov al,20h out 20h,al irqm0 dw ? ; out 0a0h,al | mov eax,eax sti cld push ebx ecx edx esi edi ebp ds mov ds, [cs:_seldata] pop ds ebp edi esi edx ecx ebx eax iretd ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Gus voice handler ; Update GUS from virtual values/commands ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _gus_handler: mov dx,gusport103 movzx ebp,_sfxnumvoices dec ebp irql0: xor cl,cl xchg cl,_vccmnd[ebp] or cl,cl jz irql0c test cl,shutup jz short irql0f9 mov edi,ebp call _gus_shutup jmp irql0c irql0f9: test cl,play jz short irql0f0 or cl,vol+pan+freq irql0f0: mov eax,ebp dec edx out dx,al inc edx cmp _mix_volume[ebp],0 jne irql0g1 gusoutb 0,1 jmp irql0c irql0g1: test cl,freq jz short irql0f1 mov bx,_vcfreq[ebp*2] cmp bx,acfreq[ebp*2] je short irql0f1 mov acfreq[ebp*2],bx gusoutw 1,bx irql0f1: test cl,pan jz short irql0f2 mov bl,_vcpan[ebp] cmp bl,acpan[ebp] je short irql0f2 mov acpan[ebp],bl gusoutb 0ch,bl irql0f2: test cl,play jz irql0f3 mov esi,_vclbeg[ebp*4] cmp esi,aclbeg[ebp*4] je short irql0f2f0 mov aclbeg[ebp*4],esi shrd bx,si,7 shr esi,7 gusoutw 2,si gusoutb 3,bh irql0f2f0: mov esi,_vclend[ebp*4] cmp esi,aclend[ebp*4] je short irql0f2f1 mov aclend[ebp*4],esi shrd bx,si,7 shr esi,7 gusoutw 4,si gusoutb 5,bh irql0f2f1: mov esi,_vcsbeg[ebp*4] shrd bx,si,7 shr esi,7 gusoutw 0ah,si gusoutb 0bh,bh gusoutb 0,_vccntrl[ebp] irql0f3: test cl,vol jz short irql0f4 movzx ebx,_vcvol[ebp] mov bl,voltbl[ebx] cmp bl,4 jbe irql0f3f4 mov bh,_mix_volume[ebp] shl bh,3 sub bh,_mix_volume[ebp] ; *7 add bl,bh sub bl,105 ; 7*15 irql0f3f4: mov bh,acvol[ebp] mov ah,bh cmp bh,bl je short irql0f4 mov ch,40h ja short irql0f3f0 xchg bl,bh xor ch,ch irql0f3f0: gusoutb 7,bl gusoutb 8,bh gusoutb 9,ah gusoutb 0dh,ch irql0f4: mov dx,300h db 7 dup(0ech) ; in al,dx mov dx,gusport103 test cl,vol jz short irql0f5 movzx ebx,_vcvol[ebp] mov al,voltbl[ebx] cmp al,4 jbe irql0f5f4 mov bh,_mix_volume[ebp] shl bh,3 sub bh,_mix_volume[ebp] ; *7 add al,bh sub al,105 ; 7*15 irql0f5f4: cmp al,ah je short irql0f5 mov acvol[ebp],al gusoutb 9,ah gusoutb 0dh,ch irql0f5: test cl,play jz short irql0c mov esi,_vcsbeg[ebp*4] shrd bx,si,7 shr esi,7 gusoutw 0ah,si gusoutb 0bh,bh gusoutb 0,_vccntrl[ebp] irql0c: sub ebp,1 jnc irql0 outb port103val ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; A small delay, In: ECX - number of times to do delay ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ gusdelay: push ax dx mov dx,300h gusdelayl0: in al,dx in al,dx in al,dx in al,dx in al,dx in al,dx in al,dx in al,dx in al,dx loop gusdelayl0 pop dx ax ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Shove some crap into GUS ram ; In: ; EBX - addx in GUS ram to shove into ; ECX - amount of crap to shove ; EDX -> actual crap to shove ; Notes: ; All incoming data will be XOR'ed with _sfxsign !!! ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _gus_putram: push eax ebx ecx edx esi push ecx mov al,_sfxsign xor al,80h gsputramlx: xor byte ptr [edx],al inc edx loop gsputramlx pop ecx sub edx,ecx mov esi,edx mov dx,gusport104 gsputraml0: dec edx mov al,44h mov port103val,al out dx,al add dl,2 shld eax,ebx,16 out dx,al sub dl,2 mov al,43h mov port103val,al out dx,al inc edx gsputraml1: mov ax,bx out dx,ax add dl,3 outsb sub dl,3 inc bx loopnz gsputraml1 jecxz short gsputramd add ebx,10000h jmp gsputraml0 gsputramd: pop esi edx ecx ebx eax ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Rip some crap outta GUS ram ; In: ; EBX - addx in GUS ram to rip from ; ECX - amount of crap to rip ; EDX -> buffer for ripped crap ; Notes: ; All outgoing data will be XOR'ed with _sfxsign !!! ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _gus_getram: push eax ebx ecx dx edi push ecx mov al,_sfxsign xor al,80h gsgetramlx: xor byte ptr [edx],al inc edx loop gsgetramlx pop ecx sub edx,ecx mov edi,edx mov dx,gusport104 gsgetraml0: dec edx mov al,44h mov port103val,al out dx,al add dl,2 shld eax,ebx,16 out dx,al sub dl,2 mov al,43h mov port103val,al out dx,al inc edx gsgetraml1: mov ax,bx out dx,ax add dl,3 insb sub dl,3 inc bx loopnz gsgetraml1 jecxz short gsgetramd add ebx,10000h jmp gsgetraml0 gsgetramd: pop edi dx ecx ebx eax ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Initialize GUS ; In: none ; Out: ; EAX = 0 ; EBX = 0 (can be used for determining if memory requuired on cpu, SB returns 1) ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _gus_init: pushad mov ax,900h int 31h push ax mov dx,_gusport ; set up all port vars outb 0bh add dx,102h mov gusport102,dx inc edx mov gusport103,dx inc edx mov gusport104,dx add dl,3 mov gusport107,dx sub dl,4 ; initialize GUS outb 4ch add dl,2 outb 0 mov ecx,10h call gusdelay outb 1 sub dl,2 mov ecx,10h call gusdelay gusoutb 41h,0 gusoutb 45h,0 gusoutb 49h,0 outb 0eh add dl,2 mov al,_sfxnumvoices dec al or al,0c0h outb al sub dl,3 mov bl,1fh ; set up all voices gsinitl0: mov al,bl and al,7fh out dx,al inc edx gusoutw 9,0 gusoutb 0,0 gusoutb 0dh,3 gusoutb 6,16 outb 0ch add dl,2 outb 7 sub dl,3 mov ecx,1 call gusdelay xor bl,80h js gsinitl0 sub bl,1 jnc gsinitl0 sub dx,0f3h ; damn, another undocumented port outb 5 sub dl,0fh outb 8 add dl,0bh xor al,al out dx,al add dl,4 out dx,al sub dl,0fh movzx ebx,_gusirq ; set IRQ channels outb 4bh add dl,0bh mov al,gusirqvaltbl[ebx] out dx,al sub dl,0bh outb 9 add dx,103h outb 43h ; how much RAM on the card inc edx outw 0ffffh dec edx outb 44h add dl,2 mov cl,3 gsinitl1: outb cl add dl,2 in al,dx inc eax mov ah,al out dx,al in al,dx sub dl,2 cmp al,ah jne short gsinitl1d inc _sfxram add cl,4 test cl,10h jz gsinitl1 gsinitl1d: sub dl,2 shl _sfxram,18 gusoutb 4ch,7 ; enable GUS normal operation cmp bl,2 ; set and enable GF1 IRQ (BL=IRQ num) jne short $+4 mov bl,9 cmp bl,7 seta al movzx eax,al mov ax,irqm0tbl[eax*2] mov irqm0,ax mov edx,offset gus_irq call _setirqvect xor al,al call _setirqmask mov edi,offset rmgusirqbuf call _rmpmirqset mov ormgusirqvect,eax mov whichguscontrol,-1 call _irq_findcontrol jc gusnogus mov _irqcontrol[ecx*4],offset _gus_handler mov whichguscontrol,ecx gusnogus: mov ecx,60 ; calculate frequency tables mov bl,_sfxnumvoices dec bl and ebx,1fh add bl,1 mov si,16 gusfreqcalc: mov ax,rawfreq[ecx*2-2] call _gus_getfreq mov _freqtbl[ecx*2-2],ax loop gusfreqcalc pop ax int 31h popad xor ebx,ebx ; memory flag, 0 = all samples on GUS xor eax,eax ; DMA memory flag. 0 = sound blaster DMA not used ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Uninitialize GUS ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _gus_uninit: push ax bx edx mov ax,900h int 31h push ax mov bl,_gusirq ; Kill GUS IRQ handler cmp bl,2 jne short $+4 mov bl,9 mov eax,ormgusirqvect call _rmpmirqfree mov al,1 call _setirqmask mov dx,gusport103 ; Shut down GUS outb 4ch add dl,2 outb 0 sub dx,105h outb 0bh mov ecx,whichguscontrol or ecx,ecx jl gusnovoice mov _irqcontrol[ecx*4],offset _ret gusnovoice: pop ax int 31h pop edx bx ax ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Find a GUS (environment variable) ; Out: ; EAX,ECX,ESI,EDI - ? ; CF=0 - found GUS ; CF=1 - no GUS found ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ pspultrastr db 'ULTRASND' _gus_find: pushad mov esi,_pspa movzx esi,word ptr gs:[esi+2ch] shl esi,4 gsfindl3: mov edi,offset pspultrastr mov ecx,8 repe cmps byte ptr gs:[esi],byte ptr es:[edi] jne short gsfindf0 mov edi,10h call gsfindr0 mov _gusport,cx call gsfindr0 call gsfindr0 mov edi,10 call gsfindr0 mov _gusirq,cl popad clc ret gsfindf0: lea esi,[esi+ecx-8] gsfindl0: inc esi cmp byte ptr gs:[esi-1],0 jne gsfindl0 cmp byte ptr gs:[esi],0 jne gsfindl3 popad stc ret gsfindr0: movzx eax,byte ptr gs:[esi] inc esi sub al,'0' jc gsfindr0 cmp al,9 ja gsfindr0 mov ecx,eax gsfindr0l0: mov al,gs:[esi] inc esi sub al,'0' jc gsfindr0d cmp al,9 ja gsfindr0d imul ecx,edi add ecx,eax jmp gsfindr0l0 gsfindr0d: ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Shut voice EDI up on GUS ; In: ; EDI - voice to kill ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _gus_shutup: push edx eax ebx mov _vccmnd[edi],0 mov dx,gusport103 mov eax,edi dec edx ; 3X2 out dx,al inc edx ; 3X3 gusinb bl,89h gusoutb 6,64+48 gusoutb 7,4 gusoutb 8,bl gusoutb 0dh,40h pop ebx eax edx ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Convert actual frequency to GUS frequency number ; In: ; EAX - frequency ; Out: ; AX - GUS frequency number ; EAX high word - ? ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _gus_getfreq: push edx ebx ebp xor ebp,ebp mov bp,_sfxmiddlec mul ebp mov ebp,8664 div ebp xor edx,edx shl eax,10 xor ebx,ebx mov bl,_sfxnumvoices cmp bl,14 jae short $+4 mov bl,14 mov bx,freqact[ebx*2-14*2] div ebx pop ebp ebx edx ret freqact dw 44100,41160,38587,36317,34300,32494,30870,29400,28063 dw 26843,25725,24696,23746,22866,22050,21289,20580,19916,19293 ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; SB lowlevel interface. - Everyone knows that the SB is OUTDATED and that ; anyone whose anybody has a GUS! These routines are for those losers... ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ public _sb_find public _sb_init public _sb_uninit public _sb_putram public _sb_getram public _sb_get_dmacount public _sb_getfreq public _sbport public _sbirq public _sbdmabuffer public _sbdmasize public _sbmixspeed public _sbvoltables public _sbsamples public _sbvolume _sbport dw 0 _sbirq db 0 _sbdmabuffer dd 0 ; DMA buffer _sbdmasize dd 0 ; DMA buffer size _sbmixspeed dw 0 ; mixing speed, (11000,22000...) _sbvoltables dd 0 ; pointer to volume tables _sbsamples dd 0 ; sample tables _sbvolume db 50 ; overall volume diminishing for samples (256=full) init only sbebp dd 0 ; temp ebp 2 dmaxor dd 0 ; xor value to flip between dma half buffers dmachunk dd 0 ; current dma chunk location (front/back) dmahalf dd 0 ; _sbdmasize /2 samend dd 0 ; current sample end location saveebp dd 0 ; temp save of ebp ormsbirqvect dd ? ; old real mode SB IRQ vector rmsbirqbuf db 21 dup(?) ; buffer for rm SB IRQ callback code ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Find a SB (environment variable) ; Out: ; EAX,ECX,ESI,EDI - ? ; CF=0 - found GUS ; CF=1 - no SB found ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ pspsbstr db 'BLASTER' _sb_find: pushad mov esi,_pspa movzx esi,word ptr gs:[esi+2ch] shl esi,4 sbfindl3: mov edi,offset pspsbstr mov ecx,7 repe cmps byte ptr gs:[esi],byte ptr es:[edi] jne short sbfindf0 mov ebx,esi mov ecx,10h mov al,"A" mov ah,"a" dec esi sbf_loop1: inc esi cmp byte ptr gs:[esi],ah je sbf_it1 cmp byte ptr gs:[esi],al loopne sbf_loop1 sbf_it1: mov edi,10h call sbfindr0 mov _sbport,cx mov ecx,10h mov al,"I" mov ah,"i" dec ebx sbf_loop2: inc ebx cmp byte ptr gs:[ebx],ah je sbf_it2 cmp byte ptr gs:[ebx],al loopne sbf_loop2 sbf_it2: mov esi,ebx mov edi,10 call sbfindr0 mov _sbirq,cl popad clc ret sbfindf0: lea esi,[esi+ecx-7] sbfindl0: inc esi cmp byte ptr gs:[esi-1],0 jne sbfindl0 cmp byte ptr gs:[esi],0 jne sbfindl3 popad stc ret sbfindr0: movzx eax,byte ptr gs:[esi] inc esi sub al,'0' jc sbfindr0 cmp al,9 ja sbfindr0 mov ecx,eax sbfindr0l0: mov al,gs:[esi] inc esi sub al,'0' jc sbfindr0d cmp al,9 ja sbfindr0d imul ecx,edi add ecx,eax jmp sbfindr0l0 sbfindr0d: ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Shut voice EDI up on SB ; In: ; EDI - voice to kill ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _sb_shutup: mov _vccmnd[edi],0 mov accmnd[edi],0 ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Sound Blaster IRQ handler ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ sb_irq: push eax mov al,20h ; re-enable irq out 20h,al irqm00 dw ? ; out 0a0h,al | mov eax,eax sti cld push ebx ecx edx esi edi ebp ds mov ds, [cs:_seldata] mov dx,_sbport ; acknowlege sound blaster add dx,0eh in al,dx mov eax,dmaxor ; we are now transferring other section... xor dmachunk,eax ; flip to other dma chunk call wipe_dmachunk call _sb_handler pop ds ebp edi esi edx ecx ebx eax iretd ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Wipe current dma chunk ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ wipe_dmachunk: push edi ecx eax mov ecx,dmahalf shr ecx,2 mov edi,dmachunk mov eax,80808080h rep stosd pop eax ecx edi ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Get current DMA location ; Out: ; ECX = > DMA load location ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _sb_get_dmacount: push eax xor ecx,ecx in al,03h ; get from dma controller mov cl,al in al,03h mov ch,al neg ecx add ecx,_sbdmasize add ecx,_sbdmabuffer dec ecx pop eax ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Initialize SB ; In: ; EDX = > free memory for DMA buffer (must be in low memory!) ; EAX = > free memory for volume tables, samples (MUST BE HIGHER THAN EDX!!) ; EBX = > DMA buffer size (dword aligned) ; CX = mixing speed (11000, 22000...) ; Out: ; CF - 1 error initalizing sound blaster ; CF - 0 ok! ; EAX = amount EDX was adjusted because of DMA page overlap. eg: add _lomembase,ebx ; this includes the original DMA size (0 if GUS) ; EBX = 1 (can be used for determining if memory required on cpu, GUS returns 0,eg: imul ebx,200000) ; ; Notes: ; If EAX < or = EDX, samples AND volume tables will follow DMA memory. ; Volume tables use 16*256 bytes of memory - make sure you remember this ; when allocating memory for samples. 200000 bytes of sample memory req'd ; means to allocate 204096 bytes of memory. ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _sb_init: pushad mov ax,900h int 31h push ax mov [esp+28+2],ebx ; mov eax,ebx after final popad mov _sbvoltables,eax mov _sbdmabuffer,edx mov _sbdmasize,ebx mov _sbmixspeed,cx add edx,_code32a mov eax,edx ; make sure actual DMA address+size does not add eax,ebx ; cross a 64k page boundary cmp ax,dx ja sb_dmatalk dec edx xor dx,dx add edx,00010000h sub edx,_code32a mov eax,_sbdmabuffer sub eax,edx neg eax add eax,ebx mov [esp+28+2],eax mov _sbdmabuffer,edx add edx,_code32a sb_dmatalk: mov ecx,ebx dec ecx mov al,05h ; program DMA controller out 0ah,al xor al,al out 0ch,al mov al,dl ; edx = location for DMA out 02h,al shr edx,8 mov al,dl out 02h,al shr edx,8 mov al,dl out 83h,al mov al,cl ; cx = length out 03h,al mov al,ch out 03h,al mov al,01h ; high length out 0ah,al mov al,59h out 0bh,al mov bl,_sbirq ; get protected mode IRQ going cmp bl,2 jne short $+4 mov bl,9 cmp bl,7 seta al movzx eax,al mov ax,irqm0tbl[eax*2] mov irqm00,ax mov edx,offset sb_irq call _setirqvect xor al,al call _setirqmask mov edi,offset rmsbirqbuf call _rmpmirqset mov ormsbirqvect,eax mov edi,_sbdmabuffer ; clear DMA buffer mov al,80h mov ecx,_sbdmasize cld rep stosb sb_resetdsp: mov dx,_sbport ; make sure SB is awake and listening add dx,06h mov al,1 out dx,al in al,dx in al,dx in al,dx in al,dx in al,dx in al,dx in al,dx in al,dx xor al,al out dx,al mov cx,100 sb_waitid: mov dx,_sbport add dx,0eh in al,dx or al,al js sb_getid loop sb_waitid stc jmp sb_error sb_getid: mov dx,_sbport add dx,0ah in al,dx cmp al,0aah je sb_sbok loop sb_waitid stc jmp sb_error sb_sbok: mov dx,_sbport add dx,0ch mov ax,1000 mul ax div _sbmixspeed neg al mov ah,al mov dx,_sbport add dx,0ch sbout 40h ; 40h = set digitized transfer time constant sbout ah sb_startdma: mov ebx,_sbdmasize shr ebx,1 dec ebx sbout 48h ; 48h = set DSP block transfer size sbout bl sbout bh sbout 1ch ; 1Ch = start auto-initialize mode sbout 0d1h ; D1h = turn sound blaster digitized sounds on mov ebx,_sbdmasize ; set pre-calculated DMA/2 size shr ebx,1 mov dmahalf,ebx mov eax,_sbdmabuffer ; set xor for chunk flipping add ebx,eax xor ebx,eax mov dmaxor,ebx mov dmachunk,eax xor dmachunk,ebx ; point active dma chunk to second half (while first half plays) cmp eax,_sbvoltables jb sb_oklocation add eax,_sbdmasize ; set volume table location mov _sbvoltables,eax sb_oklocation: mov eax,_sbvoltables mov esi,eax add eax,16*256+256 ; set location for virtual ram mov _sbsamples,eax mov ecx,16*256-1 ; generate volume tables movzx ebx,_sbvolume ; percentile volume diminishing so sample addition doesn't carry sb_volloop: movzx eax,cl sub eax,80h movzx edi,ch imul edi shr eax,4 ; shr eax,4 = full volume imul bx mov [esi+ecx],ah ; ah rather than shr eax,8 dec ecx jnl sb_volloop mov ecx,256-1 ; make master volume lookup tables sb_mastertables: mov ebx,ecx mov eax,ecx and bl,0fh shr al,4 imul ebx imul eax,17 mov ebx,15*15 idiv ebx cmp al,17 jne sb_special mov al,0fh sb_special: mov [esi+16*256+ecx],al dec ecx jnl sb_mastertables mov ecx,60 xor ebx,ebx sbpitchloop: movzx eax,rawfreq[ebx*2] call _sb_getfreq mov _freqtbl[ebx*2],ax inc ebx loop sbpitchloop pop ax int 31h popad mov ebx,1 clc ret sb_error: pop ax int 31h popad xor ebx,ebx xor eax,eax ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Unintialize SB ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _sb_uninit: pushad mov ax,900h int 31h push ax mov dx,_sbport add dx,0ch sbout 0d3h ; D3h = turn sound blaster digitized sounds off sbout 0dah ; DAh = exit auto-initialize mode mov bl,_sbirq ; restore original IRQ cmp bl,2 jne short $+4 mov bl,9 mov eax,ormsbirqvect call _rmpmirqfree mov al,1 call _setirqmask pop ax int 31h popad ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Shove some crap into SB virtual ram ; In: ; EBX - addx in SB virtual ram to shove into ; ECX - amount of crap to shove ; EDX -> actual crap to shove ; Notes: ; All incomming data will be XOR'ed with _sfxsign !!! ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _sb_putram: pushad add ebx,_sbsamples pr_loop: mov al,[edx] xor al,_sfxsign mov [ebx],al inc edx inc ebx loop pr_loop popad ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Rip some crap outta SB virtual ram ; In: ; EBX - addx in SB virtual ram to rip from ; ECX - amount of crap to rip ; EDX -> buffer for ripped crap ; Notes: ; All outgoing data will be XOR'ed with _sfxsign !!! ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _sb_getram: pushad add ebx,_sbsamples gr_loop: mov al,[ebx] xor al,_sfxsign mov [edx],al inc edx inc ebx loop gr_loop popad ret ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Main loop - Handle sound blaster mixing/voices/looping/bidirectional/volume ; ; This routine simply emulates a GUS on crappy Sound Blaster. ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _sb_handler: movzx ebp,_sfxnumvoices dec ebp _sb_moreloop: mov sbebp,ebp test _vccmnd[ebp],shutup jz short sbh_0f9 mov edi,ebp call _sb_shutup jmp sbh_next sbh_0f9: test _vccmnd[ebp],vol jz sbh_more3 mov al,_vcvol[ebp] mov acvol[ebp],al sbh_more3: test _vccmnd[ebp],freq jz sbh_more0 mov ax,_vcfreq[ebp] mov acfreq[ebp*2],ax sbh_more0: test _vccmnd[ebp],play jz sbh_more1 mov al,_vccntrl[ebp] mov accntrl[ebp],al mov eax,_vclbeg[ebp*4] add eax,_sbsamples mov aclbeg[ebp*4],eax mov edx,_vcsbeg[ebp*4] add edx,_sbsamples mov eax,_vclend[ebp*4] add eax,_sbsamples mov aclend[ebp*4],eax mov acpos[ebp*4],edx mov acstep[ebp],0 mov bh,_vcvol[ebp] mov acvol[ebp],bh mov ax,_vcfreq[ebp] mov acfreq[ebp*2],ax mov accmnd[ebp],cont mov _vccmnd[ebp],0 jmp short sbh_mixit sbh_more1: test accmnd[ebp],cont jz sbh_next sbh_mixit: mov edx,acpos[ebp*4] ; get actual sample position xor ebx,ebx ; clear top word mov bl,acvol[ebp] ; get voice volume shl bl,4 or bl,_mix_volume[ebp] ; get channel volume xor eax,eax mov ax,acfreq[ebp*2] ; get voice frequency scaling xor ecx,ecx test accntrl[ebp],loop_rev ; set Z flag of looping mov cl,ah ; transfer high step temporarily mov ah,acstep[ebp] ; get step from last time through mov edi,aclend[ebp*4] ; get sample end mov ebp,ecx ; set high step for sample increment mov samend,edi ; dont have an extra register, must save in memory mov ecx,dmahalf ; set loop counter mov edi,dmachunk ; find current DMA chunk (front/back half) mov esi,_sbvoltables ; point to volume tables mov bh,byte ptr [esi+16*256+ebx] ; mix in master volume for channel jnz sbh_subloop ; use Z flag from looping sbh_addloop: mov bl,[edx] ; mixing loop, get from sample mov bl,[ebx+esi] ; volume cross referance, bh = 0 - 15, bl = byte add [edi],bl ; mix into DMA inc edi ; inc DMA location add ah,al ; increment fractional counter adc edx,ebp ; increment integer counter cmp samend,edx ; done sample? jbe short sbh_firstshot ; yes, check for looping else exit dec ecx ; count, dec ecx is faster than loop jnz short sbh_addloop mov ebp,sbebp ; if cpu gets here, sample continues to next DMA chunk mov acpos[ebp*4],edx ; save data from this transfer to use in next mov acstep[ebp],ah jmp sbh_next sbh_firstshot: mov saveebp,ebp ; in case of looping, all registers must remain same mov ebp,sbebp test accntrl[ebp],loop_on jnz sbh_handlelooping mov ebp,sbebp ; get voice number mov accmnd[ebp],0 ; voice done, clear command mov _vccmnd[ebp],0 ; clear virtual command jmp sbh_next ; do next voice sbh_subloop: mov bl,[edx] ; backwards mixing loop: mov bl,[ebx+esi] ; volume cross referance, bh = 0 - 15, bl = byte add [edi],bl ; mix into DMA inc edi ; inc DMA location add ah,al ; increment fractional counter sbb edx,ebp ; decrement integer counter this time cmp edx,samend ; done sample? jbe short sbh_firstshot ; yes, check for looping else exit dec ecx ; count, dec ecx is faster than loop jnz short sbh_subloop mov ebp,sbebp ; if cpu gets here, sample continues to next DMA chunk mov acpos[ebp*4],edx ; save data from this transfer to use in next mov acstep[ebp],ah jmp sbh_next sbh_handlelooping: test accntrl[ebp],loop_bi jz short sbh_nobidir xor accntrl[ebp],loop_rev ; flip direction of loop push eax ebx mov eax,aclend[ebp*4] mov ebx,aclbeg[ebp*4] mov aclend[ebp*4],ebx mov aclbeg[ebp*4],eax mov samend,ebx pop ebx eax sbh_nobidir: mov edx,aclbeg[ebp*4] test accntrl[ebp],loop_rev jnz sbh_subtest mov ebp,saveebp dec ecx ; count, dec ecx is faster than loop jnz sbh_addloop sbh_next: mov ebp,sbebp dec ebp jnl _sb_moreloop ret sbh_subtest: mov ebp,saveebp ; backwards part of bi-directional loop dec ecx jnz sbh_subloop jmp short sbh_next ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ; Convert actual frequency to SB frequency number ; In: ; EAX - frequency ; Out: ; AX - SB frequency scaling number ; EAX high word - ? ;░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ _sb_getfreq: push ebp ebx mov ebp,eax mov ax,_sfxmiddlec ; make pitch tables shl eax,16 ; step[ebx]="middle c" * rawfreq[ebx] / mixrate / rawfreq[24*2] movzx ebx,_sbmixspeed cdq div ebx mul ebp mov ebp,8664 div ebp shr eax,8 pop ebx ebp ret code32 ends end